<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
</body>
<script>
    // k个一组翻转链表
// var reverseKGroup = function (head, k) {
//   if (!head || !head.next) return head;

//   let dummy = new ListNode()
//   dummy.next = head

//   let prev = dummy;
//   let curr = head;
//   let next;

//   // 求长度用于循环
//   let lHead = head;
//   let len = 0;
//   while (lHead != null ) {
//     len++
//     lHead = lHead.next;
//   }

//   let n = Math.floor(len / k) 
//   while(n--){
//     for (let j = 0; j < k - 1; j++) {

//       next2 = curr.next;
//       curr.next = next2.next;
//       next2.next = prev.next; //
//       prev.next = next2;
//     }

//     prev = curr
//     curr = prev.next
//     console.log(prev, curr)
    
//   }
//   return dummy.next
// };


// function ListNode(val, next) {
//   this.val = (val === undefined ? 0 : val)
//   this.next = (next === undefined ? null : next)
// }

// let l1 = new ListNode(1)
// let l2 = new ListNode(2)
// // let l3 = new ListNode(3)
// // let l4 = new ListNode(4)
// // let l5 = new ListNode(5)
// // let l6 = new ListNode(6)
// l1.next = l2;
// // l2.next = l3;
// // l3.next = l4;
// // l4.next = l5;
// // l5.next = l6;

// console.log(reverseKGroup(l1, 2))


// var reverseListMN = (head, m, n) => {
//   let dummy = new ListNode(0);
//   dummy.next = head;

//   // 找到第m个节点位置
//   let prev = dummy;
//   for (let i = 0; i < m - 1; i++) { // 保证目标前一个
//     prev = prev.next;
//   }

//   let cur = prev.next;
//   for (let i = 0; i < n - m ; i++) {
//     let next = cur.next;
//     cur.next = next.next; // 
//     next.next = prev.next; // 
//     prev.next = next; // 
//   }

//   return dummy.next;
// }

// function ListNode(val, next) {
//   this.val = (val === undefined ? 0 : val)
//   this.next = (next === undefined ? null : next)
// }

// let l1 = new ListNode(1)
// let l2 = new ListNode(2)
// let l3 = new ListNode(3)
// let l4 = new ListNode(4)
// let l5 = new ListNode(5)
// let l6 = new ListNode(6)
// l1.next = l2;
// l2.next = l3;
// l3.next = l4;
// l4.next = l5;
// l5.next = l6;

// console.log(reverseListMN(l1, 2, 4))


// var solveNQueens = function(n) {
//     let res = [];
//     let temp = Array.from(new Array(n), () => (Array(n).fill('.')));
//     let dep = 0;

//     console.log(temp[0])

//     let left = new Set()
//     let right = new Set()
//     let cols = new Set()

//     const bactracking = (row) => {
//         if(row === n){
//           return res.push(temp.map((item) => (item.join('.'))))
//         }

//         for(let col = 0; col< n; col++){
//             if(!left.has(col- row) && !right.has(col + row) && !cols.has(col)){
//                 temp[row][col] = 'Q'
//                 cols.add(col);
//                 left.add(col- row)
//                 right.add(col + row)
//                 bactracking(row+1)
//                 cols.delete(col);
//                 left.delete(col- row)
//                 right.delete(col + row)
//                 temp[row][col] = "."
//             }
//         }
//     }
//     bactracking(dep)
//     return res

// };

// console.log(solveNQueens(4))


// var monotoneIncreasingDigits = function(n) {
//     // 倒序， 每一个非单调递减的 都当前变为9，前一位-1
//     let str = n.toString();
//     let arr = str.split('').map(res => res*1);
//     let index = str.length;
//     console.log(arr)
//     for(let i = arr.length-1; i > 0; i--){
//       console.log(arr[i-1], arr[i])
//         if(arr[i-1] > arr[i]){
//           console.log(arr[i-1])
//           arr[i-1] = arr[i-1] - 1;
//             console.log(arr[i-1])
//             arr[i] = 9
//             index = i
//         } 
//     }
//     console.log(str)
    
//     for(let i = index; i< arr.length; i++){
//       arr[i] = 9
//     }
    
//     return +arr.join('')

// };
// console.log(monotoneIncreasingDigits(10))


// var longestCommonPrefix = function(strs) {
//     let comom = strs[0]
//     for(let i = 1; i< strs.length; i++){
//       let j = 0; 
//         for(j< comom.length && j < strs[i].length; j++){
//             console.log(j, comom[j], strs[i][j])
//             if(comom[j] !== strs[i][j]){

//                 console.log(comom, j)
//                 break
//             }
//         }
//         comom = comom.substring(0, j)
//     }
//     return comom

// };

// console.log(longestCommonPrefix(["ab", "a"]))

// var reverseStr = function(s, k) {
//     let arr = s.split('')
//     for(let i =0; i< arr.length; i += 2 * k){
//       console.log(i)
//         let len = arr.length - i > k? k: arr.length - i
//         console.log(len)
//         for(let j = 0; j< len / 2; j++){
//           console.log(i+j, len+ i - j -1);
//             [arr[i+j], arr[len  + i -1]] = [ arr[len + i -1],arr[i+j]]
//         }
//     }

//     return arr.join('')

// };

// console.log(reverseStr('abcdef', 3))


// var isPalindrome = function(s) {
//     s = s.replace(/[^a-zA-Z0-9]/g, "").replace(/\s/g, '').toLowerCase()
//   console.log(res);
//     let left = 0;
//     let right = s.length - 1;
//     while(left < right){
//         if(s[left] !== s[right]) return false
//         left++
//         right++
//     }

//     return true

// };

// console.log(isPalindrome("A man, a plan, a canal: Panama"))



// var MedianFinder = function() {
//     this.store = []
// };

// /** 
//  * @param {number} num
//  * @return {void}
//  */
// MedianFinder.prototype.addNum = function(num) {
//   if(!this.store.length) return this.store.push(num)
//     let index = -1;
//     // 找到对应的index， 单调递增
//     for(let i = this.store.length - 1; i >= 0; i--){
//         if(this.store[i] < num){
//             index = i
//             break
//         }
//     }

//     this.store.splice(index + 1, 0, num) // splice 插入删除，slice 切割

//     console.log(this.store)
// };

// /**
//  * @return {number}
//  */
// MedianFinder.prototype.findMedian = function() {
//   let mid = Math.floor(this.store.length / 2);
//     if(this.store.length % 2) {
//         return this.store[mid]
//     } else {

//         return (this.store[mid] + this.store[mid - 1])/2
//     }
// };

// let a = new MedianFinder()
// a.addNum(6)
// console.log(a.findMedian())
// a.addNum(10)
// console.log(a.findMedian())
// a.addNum(2)
// console.log(a.findMedian())


// var threeSum = function(nums) {
//     let res = [];
//     nums.sort((a, b) => (a - b)); // 单调递增
//     console.log(nums);
//     for(let i = 0; i< nums.lenght; i++){
//       console.log('ooooo', nums[i], i, nums[i-1])
//         if(nums[i] > 0) break;
//         if(i> 0 && nums[i] === nums[i-1]) continue;
//         console.log('ooooo')
//         let l = i+1;
//         let r = nums.length - 1;
//         console.log(l, r)
//         while(l < r){
//             let sum = nums[i] + nums[l] + nums[r];
//             console.log(sum)
//             if(sum < 0) { l++; continue} // 小了得加
//             if(sum > 0) { r--; continue} // 大了得小点
//             res.push([nums[i], nums[l], nums[r]])
//             // 去重
//             while(l < r && nums[l] === nums[l+1]) l++;
//             while(l < r && nums[r] === nums[r -1]) r--;
//             l++
//             r--
//         }   
//     }
//     return res;

// };

// console.log(threeSum([-1,0,1,2,-1,-4]))

// var fourSum = function(nums, target) {
//     let res = [];
//     nums.sort((a, b) => a-b);
//     for(let i =0; i< nums.length-3; i++){
//         if(i> 0 && nums[i] === nums[i-1]) continue;
//         for(let j = i+1; j< nums.length-2; j++){
//             if(j> i+ 1 && nums[j] === nums[j-1]) continue;
//             let l = j = 1;
//             let r = nums.length - 1;
//             while(l < r) {
//                 let sum = nums[i] + nums[j] + nums[l] + nums[r];
//                 if(sum < target) {l++; continue}
//                 if(sum > target) {r--; continue}
//                 res.push([nums[i], nums[j], nums[l], nums[r]])
//                 while(l<r && nums[l] === nums[l+1]) l++;
//                 while(l < r && nums[r] === nums[r-1]) r--;
//                 l++;
//                 r-- 
//             }
//         }
//     }
//     return res;
// };

// console.log(fourSum([1,0,-1,0,-2,2], 0))

// var reverseBetween = function(head, left, right) {
//     let dummy = new ListNode();
//     dummy.next = head;

//     let pre = dummy;
//     for(let i =0; i < left - 1; i++){
//         pre = pre.next
//     }

//     let cur = pre.next
//     for(let i =0 ; i< right - left; i++){
//         let next = cur.next;
//         cur.next = next.next;
//         next.next = pre.next
//         pre.next = next
//     }


//     return dummy.next
// };

// let head = new ListNode(1)
// let a = new ListNode(2)
// let b = new ListNode(3)
// let c = new ListNode(4)

// console.log(reverseBetween())/


// var mergeKLists = function(lists) {
//     // 转换为数组问题
//     let arr = [];
//     for(let i =0; i< lists.length; i++){
//         while(lists[i]){
//             arr.push(lists[i].val)
//             lists[i] = lists[i].next
//         }
//     }

//     let dummy = new ListNode()
//     arr.sort((a, b) => (a - b));
//     // 倒序，倒序 很重要
//     // for(let i = arr.length - 1; i >= 0; i--){
//     //     dummy.val = arr[i];
//     //     // 构造【前一个】，next 为当前
//     //     let list = new ListNode();
//     //     list.next = dummy
//     //     dummy = list

//     // }
//     // return dummy.next

//     let head = dummy 
//     for(let i = 0; i< arr.lenght; i++){
//         // 构造【前一个】，next 为当前
//         let list = new ListNode(arr[i]);
//         dummy.next = list
//         dummy = list

//     }
//     return head.next

// };


// var addStrings = function(num1, num2) {
//     // 大数相加
//     let up = 0; // 进位
//     let res = ''; // 结果

//     let m = num1.length; 
//     let n = num2.length;
//     let max = m > n ? m : n
//     let arr1 = num1.padStart( max, 0)
//     let arr2 = num2.padStart(max, 0)

//     console.log(arr1, arr2)

//     for(let i = max -1; i >= 0; i--){
//         let n1 = parseInt(arr1[i]) 
//         let n2 = parseInt(arr2[i])
//         let num = n1 + n2 + up * 1;
//         let nu = num % 10
//         up = Math.floor(num/10)
//         res = nu.toString() + res.toString()
//     }

//     return up > 0 ? ('1' + res) : res

// };

// console.log(addStrings("11", '123'))


// var lengthOfLIS = function(nums) {
//     let dp = new Array(nums.length).fill(1) // dp[i] 0-i 递增子序列的长度
//     for(let i = 0; i< nums.length; i++){
//         for(let j =0; j< i; j++){
//             if(nums[i] > nums[j]){ // 当前值，大于目标值，递增
//                 dp[i] = Math.max(dp[j] + 1, dp[i])
//             }
//         }
//     }
//     // return Math.max(...dp) // 这里是求
//     console.log(dp)
//     return dp[nums.length - 1]
// };

// console.log(lengthOfLIS([1,4,3,4,2]))


var maxProduct = function(nums) {
    // 因为有正负数，存每个位置的最大值 和最小值
    let max = nums[0];
    let min = nums[0];
    let res = nums[0]
    for(let i = 1; i< nums.length; i++){
        if(nums[i] < 0){
            
            max = Math.max(min * nums[i], nums[i])
            min = Math.min(max * nums[i], nums[i])
            console.log('0000', max, min)
        } else {
            max = Math.max(max * nums[i], nums[i])
            min = Math.min(min * nums[i], nums[i])
            console.log('1111', max, min)
        }

        // if(nums[i] < 0){
        //     let temp = max;
        //     max = min;
        //     min = temp
        // }

        // max = Math.max(max*nums[i], nums[i])
        // min = Math.min(min*nums[i], nums[i])

        res = Math.max(res, max)
        console.log(nums[i], max, min, res)
    }

    return res;

};

console.log(maxProduct([-4,-3,-2]))

</script>
</html>